package com.sd365.permission.centre.api.controller;

/**
 * @author HeJiaLe
 * @author HeJiaLe
 * @Date 2023/8/3 17:33
 * /
 * <p>
 * /**
 * 角色管理测试
 * @date 2023/08/03 17:33
 **/

import java.util.*;


import com.sd365.common.core.context.BaseContextHolder;
import com.sd365.permission.centre.pojo.dto.*;
import com.sd365.permission.centre.pojo.query.RoleQuery;
import com.sd365.permission.centre.service.ResourceService;
import com.sd365.permission.centre.service.RoleService;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.omg.PortableServer.LIFESPAN_POLICY_ID;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.CollectionUtils;
import rx.observers.AssertableSubscriber;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.stream.Collectors;

@RunWith(SpringRunner.class)
@SpringBootTest
class RoleControllerTest2 {
 @Resource
 private RoleController roleController;
 @Autowired
 private RedisTemplate redisTemplate;
 /**
  * 测试角色
  */
 @javax.annotation.Resource
 private RoleService roleService;
 @javax.annotation.Resource
 ResourceService resourceService;
 @Test
 void add() {
  //测试加入一个不存在的角色，并且输入信息完整
  RoleDTO roleDTO = new RoleDTO();
  roleDTO.setName("cy");
  roleDTO.setCode("123456");
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
  BaseContextHolder.setTanentId(1337940702788714496L);
  Assert.assertTrue(roleController.add(roleDTO));
 }
 @Test
 void add4() {
  RoleDTO roleDTO = new RoleDTO();
  roleDTO.setName("wy");
  roleDTO.setCode("1233334");
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
  BaseContextHolder.setTanentId(1337940702788714496L);
  Assert.assertTrue(roleController.add(roleDTO));
 }
 @Test
  //测试已存在的角色是否能增加成功
 void add1(){
  RoleDTO roleDTO = new RoleDTO();
  roleDTO.setName("wyb");
  roleDTO.setCode("123");
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
  BaseContextHolder.setTanentId(1337940702788714496L);
  Assert.assertTrue(roleController.add(roleDTO));
 }

 @Test
  //测试输入不完整是否能进行增加
 void add2(){
  RoleDTO roleDTO = new RoleDTO();
  roleDTO.setName("wyb3");
  // roleDTO.setCode("123");
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
  BaseContextHolder.setTanentId(1337940702788714496L);
  Assert.assertTrue(roleController.add(roleDTO));
 }

 /**
  * 传参id和version为null，判处异常
  */
 @Test
 void remove() {
  Assert.assertTrue(roleController.remove(null, null));
 }

 /**
  * 删除一个不存在的角色
  */
 @Test
 void remove1(){
  Assert.assertTrue(roleController.remove(1686934115267510272L, 0L));

 }

 /**
  * 删除一个不存在的角色
  */
 @Test
 void remove2(){
  //传入不存在的id
  Assert.assertTrue(roleController.remove(168693272L, 0L));

 }

 /**
  * 批量删除
  */
 @Test
 void batchRemove() {
  //测试删除一条数据
  RoleDeleteDTO[] deleteroleDTOS = new RoleDeleteDTO[1];
  RoleDeleteDTO dto1 = new RoleDeleteDTO();
  dto1.setId(1686991118354481152L);
  dto1.setVersion(2L);
  deleteroleDTOS[0] = dto1;
  Assert.assertTrue(roleService.batchRemove(deleteroleDTOS));

 }
 // 测试步骤1
 //DeleteRoleDTO dto2 = new DeleteRoleDTO();
 // 测试删除一条角色数据的时候是否成功
 // 测试步骤2
 // 测试删除2条角色数据的时候是否成功
 // 测试步骤3
 // 测试参数数组为空的时候 是否触发异常
 // 测试步骤4
 // 测试参数数组不为空 但是id为空的时候是否异常
 // 测试步骤5
 // 传入数组中包含触发异常的测试数据 是否回滚事务，可以通过service的联合查询方法来验证

 /**
  * 批量删除判空，数组不为空
  */
 @Test
 void batchRemove1() {
  //测试参数数组不为空 但是id为空的时候是否异常
  RoleDeleteDTO[] deleteroleDTOS = new RoleDeleteDTO[1];
  RoleDeleteDTO dto1 = new RoleDeleteDTO();
  deleteroleDTOS[0] = dto1;
  Assert.assertTrue(roleService.batchRemove(deleteroleDTOS));
 }

 /**
  * 批量删除判空，数组为空
  */
 @Test
 void batchRemove2() {
  //测试数组为空
  RoleDeleteDTO[] deleteroleDTOS = new RoleDeleteDTO[1];
  Assert.assertTrue(roleService.batchRemove(deleteroleDTOS));
 }

 /**
  * 批量删除两条不存在的role
  */
 @Test
 void batchRemove3() {
  //测试删除两条数据
  RoleDeleteDTO[] deleteroleDTOS = new RoleDeleteDTO[2];
  RoleDeleteDTO dto1 = new RoleDeleteDTO();
  dto1.setId(1686940339102941184L);
  dto1.setVersion(0L);
  deleteroleDTOS[0] = dto1;
  RoleDeleteDTO dto2 = new RoleDeleteDTO();
  dto2.setId(1337960193258029056L);
  dto2.setVersion(0L);
  deleteroleDTOS[1] = dto2;
  Assert.assertTrue(roleService.batchRemove(deleteroleDTOS));
 }

 // 测试步骤1
 // 测试传入必输项完整的RoleDTO对象，成功修改

 @Test
 void modify() {
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
  BaseContextHolder.setTanentId(1337940702788714496L);

  //RoleDTO roleDTO = roleService.queryById(1687035479024861184L);
 // roleDTO.setName("wowo");
 // RoleDTO modifiedRoleDTO = roleService.modify(roleDTO);
  //Assert.assertEquals("wowo", modifiedRoleDTO.getName());

 }
 // 测试步骤2
 // 测试传入必输项目不完整的对象，校验不通过触发异常
 @Test
 void modify2() {
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
 // RoleDTO roleDTO = roleService.queryById(1687035479024861184L);
//  roleDTO.setCode(null);
 // roleDTO.setName("wowo");
  //RoleDTO modifiedRoleDTO = roleService.modify(roleDTO);
  //Assert.assertEquals("wowo", modifiedRoleDTO.getName());

 }
 // 测试步骤3
 // 测试传入编号重复的角色对象 修改不成功
 @Test
 void modify3() {
  BaseContextHolder.setCompanyId(1337960193258029056L);
  BaseContextHolder.setOrgId(1337955940401545216L);
 // RoleDTO roleDTO = roleService.queryById(1687035479024861184L);
  //roleDTO.setCode("000");
  //RoleDTO modifiedRoleDTO = roleService.modify(roleDTO);
 // Assert.assertEquals("wowo", modifiedRoleDTO.getName());
 }

 /**
  * 为角色分配资源
  */
 @Test
 void assignResource() {
  //测试步骤1
  // 测试为一个新的角色分配 5条系统资源 分配成功
  RoleResourceDTO roleResourceDTO = new RoleResourceDTO();
  // 角色列表
  List<Long> roleIds = new ArrayList<>();
  roleIds.add(1687035479024861184L);
  roleIds.add(1687035486620745728L);
  // 资源列表
//        roleResourceDTO.getResourceIds().stream().collect(Collectors.toSet());
  List<Long> resourceIds = new ArrayList<>();
  resourceIds.add(15484897788l);
  resourceIds.add(30031250792l);
  // 装入对象
  roleResourceDTO.setRoleIds(roleIds);
  roleResourceDTO.setResourceIds(resourceIds);
  //　测试为一个已经分配资源的角色新增2条资源　分配成功　资源数量正确
  Assert.assertEquals(roleService.assignResource(roleResourceDTO),true);
 }

 /**
  * 为用户分配角色
  */
 @Test
 void assignUser() {
  UserRoleDTO userRoleDTO = new UserRoleDTO();
  // 角色列表
  List<Long> roleIds = new ArrayList<>();
  roleIds.add(1687035479024861184L); roleIds.add(1687035486620745728L);
  List<Long> userIds = new ArrayList<>();
  roleIds.add(1337970508645400576L); userIds.add(1473568467948011520L);
  // 分配入对象
  userRoleDTO.setRoleIds(roleIds);
  userRoleDTO.setUserIds(userIds);

  Boolean flag = true;
  Assert.assertEquals(flag,true);
 }

 /**
  * 判断角色是否存在
  */
 @Test
 void haveRole() {
  //传入存在的roleId
  //RoleDTO roleDTO = roleService.queryById(1665557940188348417L);
 // Assert.assertTrue(roleService.haveRole(roleDTO));

 }

 /**
  * 判断角色是否村庄
  */
 @Test
 void haveRole1(){
  //传入不存在的roleId
  RoleDTO roleDTO=new RoleDTO();
  roleDTO.setId(123456789876543456L);
  Assert.assertFalse(roleService.haveRole(roleDTO));
 }
}